/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package gradius.Elementos;

import gradius.InterfaceGrafica.BackGroundImage;
import gradius.InterfaceGrafica.TelaGrafica;
import gradius.Elementos.Naves.Nave;
import gradius.Elementos.Naves.NaveFactory;
import gradius.Elementos.Naves.Upgrade;
import gradius.Elementos.Naves.UpgradeFactory;
import java.awt.Image;
import java.awt.Toolkit;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.StringTokenizer;

/** Classe para leitura de arquivos que contem informações das fases e dos inimigos, e suas posições
 *
 * @author Eduardo
 */
public final class StageReader
{
    /** Método usado para leitura, no arquivo, de imagens do cenário na fase atual
     *
     * @param stage - Parâmetro que representa o cenário(fase) do jogo
     * @return ArrayList<BackGroundImage> - Retorna um ArrayList de imagens do cenário
     * @throws FileNotFoundException - Exceção de arquivo não encontrado
     * @throws IOException - Exceção de IO
     */
    public static ArrayList<BackGroundImage> lerImagensCenario(int stage) throws FileNotFoundException, IOException
    {
        String linha = "/stages/" + stage + ".txt";
        URL url = StageReader.class.getResource(linha);
        FileReader reader = new FileReader(new File(url.getPath()));
        BufferedReader breader = new BufferedReader(reader);
        boolean flag = true;
        boolean lerCenario = false;
        ArrayList<BackGroundImage> array = new ArrayList<BackGroundImage>();
        array.clear();
        while(flag)
        {
            linha=breader.readLine();
            if ((linha.equals("</cenario>"))||(linha==null))
            {
                flag=false;
            }
            else
            {
                if (linha.equals("<cenario>"))
                {
                    lerCenario=true;
                }
                else
                {
                    if (lerCenario)
                    {
                        Image imagem;
                        url = StageReader.class.getResource(linha);
                        imagem = Toolkit.getDefaultToolkit().getImage(url);
                        array.add(new BackGroundImage(imagem));
                    }
                }
            }
        }
        reader.close();
        breader.close();
        return array;
    }

    /** Método usado para leitura, no arquivo, de imagens dos elementos na fase atual
     *
     * @param stage - Parâmetro que representa o cenário(fase) do jogo
     * @return ArrayList<BackGroundImage> - Retorna um ArrayList de imagens dos elementos da fase atual
     * @throws FileNotFoundException - Exceção de arquivo não encontrado
     * @throws IOException - Exceção de IO
     */
    public static ArrayList<BackGroundImage> lerImagensElementos(int stage) throws FileNotFoundException, IOException
    {
        String linha = "/stages/" + stage + ".txt";
        URL url = StageReader.class.getResource(linha);
        FileReader reader = new FileReader(new File(url.getPath()));
        BufferedReader breader = new BufferedReader(reader);
        boolean flag = true;
        boolean lerElemento = false;
        ArrayList<BackGroundImage> array = new ArrayList<BackGroundImage>();
        array.clear();
        while(flag)
        {
            linha=breader.readLine();
            if ((linha.equals("</elementos>"))||(linha==null))
            {
                flag=false;
            }
            else
            {
                if (linha.equals("<elementos>"))
                {
                    lerElemento=true;
                }
                else
                {
                    if (lerElemento)
                    {
                        Image imagem;
                        String a,b,c,d;
                        StringTokenizer st = new StringTokenizer(linha," ");
                        a=st.nextToken();
                        b=st.nextToken();
                        c=st.nextToken();
                        d=st.nextToken();
                        url = StageReader.class.getResource(a);
                        imagem = Toolkit.getDefaultToolkit().getImage(url);
                        array.add(new BackGroundImage(imagem, Integer.parseInt(b), Integer.parseInt(c), Integer.parseInt(d)));
                    }
                }
            }
        }
        reader.close();
        breader.close();
        return array;
    }

    /** Método usado para leitura, no arquivo, de naves inimigas na fase atual
     *
     * @param stage - Parâmetro que representa o cenário(fase) do jogo
     * @return ArrayList<BackGroundImage> - Retorna um ArrayList de inimigos da fase atual
     * @throws FileNotFoundException - Exceção de arquivo não encontrado
     * @throws IOException - Exceção de IO
     */
    public static ArrayList<Nave> lerInimigos(TelaGrafica tela, int stage) throws FileNotFoundException, IOException
    {
        String linha = "/stages/" + stage + ".txt";
        URL url = StageReader.class.getResource(linha);
        FileReader reader = new FileReader(new File(url.getPath()));
        BufferedReader breader = new BufferedReader(reader);
        boolean flag = true;
        boolean lerInimigo = false;
        ArrayList<Nave> array = new ArrayList<Nave>();
        array.clear();
        while(flag)
        {
            linha=breader.readLine();
            if ((linha.equals("</inimigos>"))||(linha==null))
            {
                flag=false;
            }
            else
            {
                if (linha.equals("<inimigos>"))
                {
                    lerInimigo=true;
                }
                else
                {
                    if (lerInimigo)
                    {
                        String a,b,c;
                        StringTokenizer st = new StringTokenizer(linha," ");
                        a=st.nextToken();
                        b=st.nextToken();
                        c=st.nextToken();
                        array.add(NaveFactory.getInstance(tela, Tipos.tipoNave.valueOf(a), Integer.parseInt(b), Integer.parseInt(c)));
                    }
                }
            }
        }
        reader.close();
        breader.close();
        return array;
    }

    /** Método usado para leitura, no arquivo, do numero de naves inimigas na fase atual
     *
     * @param stage - Parâmetro que representa o cenário(fase) do jogo
     * @return int - Retorna o numero de inimigos da fase atual
     * @throws FileNotFoundException - Exceção de arquivo não encontrado
     * @throws IOException - Exceção de IO
     */
    public static int lerNumeroInimigos(int stage) throws IOException
    {
        String linha = "/stages/" + stage + ".txt";
        URL url = StageReader.class.getResource(linha);
        FileReader reader = new FileReader(new File(url.getPath()));
        BufferedReader breader = new BufferedReader(reader);
        boolean flag = true;
        int n = 0;
        while(flag)
        {
            linha=breader.readLine();
            if ((linha.equals("</ninimigos>"))||(linha==null))
            {
                flag=false;
            }
            else
            {
                if (linha.equals("<ninimigos>"))
                {
                    linha=breader.readLine();
                    n = (int)Integer.parseInt(linha);
                    flag = false;
                }
            }
        }
        reader.close();
        breader.close();
        return n;
    }

    /** Método usado para leitura, no arquivo, dos upgrades na fase atual
     *
     * @param stage - Parâmetro que representa o cenário(fase) do jogo
     * @return ArrayList<BackGroundImage> - Retorna um ArrayList dos upgrades da fase atual
     * @throws FileNotFoundException - Exceção de arquivo não encontrado
     * @throws IOException - Exceção de IO
     */
    public static ArrayList<Upgrade> lerUpgrades(TelaGrafica tela, int stage) throws FileNotFoundException, IOException
    {
        String linha = "/stages/" + stage + ".txt";
        URL url = StageReader.class.getResource(linha);
        FileReader reader = new FileReader(new File(url.getPath()));
        BufferedReader breader = new BufferedReader(reader);
        boolean flag = true;
        boolean lerUpgrade = false;
        ArrayList<Upgrade> array = new ArrayList<Upgrade>();
        array.clear();
        while(flag)
        {
            linha=breader.readLine();
            if ((linha.equals("</upgrades>"))||(linha==null))
            {
                flag=false;
            }
            else
            {
                if (linha.equals("<upgrades>"))
                {
                    lerUpgrade=true;
                }
                else
                {
                    if (lerUpgrade)
                    {
                        String a,b;
                        StringTokenizer st = new StringTokenizer(linha," ");
                        a=st.nextToken();
                        b=st.nextToken();
                        array.add(UpgradeFactory.getInstance(tela, Integer.parseInt(a), Integer.parseInt(b)));
                    }
                }
            }
        }
        reader.close();
        breader.close();
        return array;
    }
}
